10th international ABINIT developer workshop
20-22nd May 2019 - Louvain-la-Neuve, Belgium

Use the Space key to navigate through all slides.
NB: There's an ongoing effort to reimplement AbiFlows in terms of the atomate framework
Using conda and the conda forge channel (recommended):
conda install abipy --channel conda-forge
Recipes for AbiPy and ABINIT are now supported by the conda-forge community 🎉
This means that:
Since conda is not limited to python packages, one can install ABINIT in the same env with:
conda install abinit -c conda-forge
Using pip and python wheels:
pip install abipy --user
From the github repository (develop mode):
git clone https://github.com/abinit/abipy.git
cd abipy
python setup.py develop
For further info see http://abinit.github.io/abipy/installation.html
%embed https://abinit.github.io/abipy/index.html
%embed https://abinit.github.io/abipy/gallery/plot_phbands_nkpt_tsmear.html#sphx-glr-gallery-plot-phbands-nkpt-tsmear-py
%embed https://nbviewer.jupyter.org/github/abinit/abitutorials/blob/master/abitutorials/index.ipynb
New Flows to compute:
New flows and post-processing tools for:
(contributed by G. Petretto)
Based on py script by A. Romero. ...
Applications:
Example: obtain irreps from DDB using phonopy
Flow to run DFPT calculations to compute:
For the formalism see:
Python API:
scf_input = make_scf_input() # Build input for GS calculation
elast_work = flowtk.ElasticWork.from_scf_input(scf_input,
with_relaxed_ion=True,
with_piezo=True)

Flow to run DFPT calculations to compute:
For the formalism see:
scf_input = make_scf_input() # Get the SCF input (without SOC)
from abipy.flowtk.effmass_works import EffMassAutoDFPTWork
flow = flowtk.Flow("effmass_flow")
work = EffMassAutoDFPTWork.from_scf_input(scf_input)
flow.register_work(work)

Flow to run DFPT calculations to compute:
This example shows how to compute the e-ph matrix elements in AlAs along a q-path with AbiPy flows. The final results are stored in the GKQ.nc file (one file for q-point) in the outdata of each task.
# Build input for GS calculation on a 2x2x2 k-mesh
scf_input = make_scf_input(ngkpt=(2, 2, 2))
# q-mesh for phonons
ngqpt = (2, 2, 2)
# Create flow to compute all the independent atomic perturbations
# Use ndivsm = 0 to pass an explicit list of q-points.
# If ndivsm > 0, qpath_list is interpreted as a list of boundaries for the q-path
qpath_list = [[0.0, 0.0, 0.0], [0.01, 0, 0], [0.1, 0, 0],
[0.24, 0, 0], [0.3, 0, 0], [0.45, 0, 0], [0.5, 0.0, 0.0]]
from abipy.flowtk.eph_flows import GkqPathFlow
flow = GkqPathFlow.from_scf_input("flow_dir", scf_input,
ngqpt, qpath_list, ndivsm=0, with_becs=True,
ddk_tolerance={"tolwfr": 1e-8})
Formalism:
https://abinit.github.io/abipy/flow_gallery/run_gkq.html#sphx-glr-flow-gallery-run-gkq-py

For other AbiPy e-ph flows see:


gsr = abiopen("si_nscf_GSR.nc")
gsr.ebands.plot(with_gaps=True);
(contributed by Y. He and MG)
gsr.ebands.plotly(with_gaps=True); # Replace *object.plot* becomes *object.plotly*
gsr.ebands.plotly(with_gaps=True, chart_studio=True);

#%embed https://chart-studio.plotly.com/~gmatteo/214
gsr.ebands.kpoints.plotly();
gsr.ebands.kpoints.plot();

Thanks to this infrastructure, developers can use python to solve the scientific problem using the pydata ecosystem and the packages developed by the ab-initio community.

To build a panel GUI inside the notebook, use:
ddb = abilab.abiopen("ZnSe_hex_qpt_DDB")
abilab.abipanel();
ddb.get_panel()
ddb.structure.get_panel()
To create a panel dashboard associated to the DDB file, use:
abiopen.py ZnSe_hex_qpt_DDB --panel # or -pn if you prefer the short version.
abiopen.py mgb2_kpath_FATBANDS.nc --expose --seaborn
abiopen.py mgb2_kpath_FATBANDS.nc --expose-web # -ewb
abiopen.py mgb2_kpath_FATBANDS.nc --plotly # -ply

to get a quick look at the results
abiview.py ddb ZnSe_hex_qpt_DDB --panel # or -pn if you prefer the short version.
## Documentation of new features available at:
%embed https://abinit.github.io/abipy/graphical_interface.html
abiview.py ddb ZnSe_hex_qpt_DDB --seaborn
Use AbiPy programmatic interface to implement: